home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / et / src / math.c < prev    next >
Text File  |  1993-07-08  |  11KB  |  442 lines
  1. #include  "et.h"
  2. void  make_name(void)/*et*/
  3. {
  4.   int   p_i, q_i, i;
  5.   unsigned  f, h, u, v, k, n, *buf_p, *icn_p;
  6.   VRAM  *vram_p;
  7.   char  *c_p, *s_p;
  8.   
  9.   f = test_bit(G_f, f_SV|f_GPH|f_VIEW|f_EE|f_TT);
  10.   if (test_bit(G_f, f_SV|f_GPH)) {
  11.     if (test_bit(G_f, f_SS)) {
  12.       copy_edge(STORE, AFT);
  13.       i = 0;
  14.       res_bit(G_f, f);
  15.       go_bar(&i, 7, 0);
  16.       set_bit(G_f, f);
  17.       draw_frame3(P_i[i_WIN_VIEW]);
  18.       copy_edge(RESTORE, AFT);
  19.     } else if (test_bit(G_f, f_EE)) {
  20.       cls_view(P_i[i_WIN_VIEW]);
  21.       res_bit(G_f, f);
  22.       cul_edge(G_et, G_edge, G_nb.edge, 0, ENT);
  23.       set_bit(G_f, f);
  24.       draw_frame3(P_i[i_WIN_VIEW]);
  25.     }
  26.   }
  27.   buf_p = P_v[v_ICN];
  28.   icn_p = P_v[v_VRAM];
  29.   p_i = P_i[i_WIN_VIEW][0];
  30.   q_i = P_i[i_WIN_VIEW][1];
  31.   vram_p = vram_addr(p_i, q_i, !G_nb.page);
  32.   if (test_bit(G_f, f_AA))
  33.     s_p = P_c[c_COL_A];
  34.   else if (test_bit(G_f, f_NN))
  35.     s_p = P_c[c_COL_G];
  36.   else 
  37.     s_p = P_c[c_COL_N];
  38.   while (1) {
  39.     c_p = s_p;
  40.     v = n = 0;
  41.     while (1) {
  42.       for (u = *c_p; u; u <<= 4) {
  43.         k = _peek_longword(0x120, (int)vram_p);
  44.         if (k)
  45.           for (h = *c_p; h; h <<=4 )
  46.             if (test_bit(k, h) == h) {
  47.               v |= u;
  48.               break;
  49.             }
  50.         vram_p++;
  51.       }
  52.       if (!*(++c_p))
  53.         break;
  54.       vram_p -= 8;
  55.     }
  56.     *icn_p++ = v;
  57.     p_i += 64;
  58.     if (p_i < P_i[i_WIN_VIEW][2])
  59.       continue;
  60.     p_i = P_i[i_WIN_VIEW][0];
  61.     q_i++;
  62.     if (q_i < P_i[i_WIN_VIEW][3])
  63.       vram_p = vram_addr(p_i, q_i, !G_nb.page);
  64.     else
  65.       break;
  66.   }
  67.   k = P_i[i_SIZE_ICN][2];
  68.   vram_p = P_v[v_VRAM];
  69.   while (1) {
  70.     v = 0;
  71.     for (u = 8; u; u--, vram_p += P_i[i_SIZE_ICN][2])
  72.       v |= *vram_p;
  73.     *buf_p++ = v;
  74.     if (--k)
  75.       vram_p -= P_i[i_SIZE_ICN][2] * 8;
  76.     else {
  77.       vram_p -= P_i[i_SIZE_ICN][2];
  78.       k = P_i[i_SIZE_ICN][2];
  79.     }
  80.     vram_p++;
  81.     if (buf_p >= P_v[v_ICN] + P_i[i_SIZE_ICN][2] * P_i[i_SIZE_ICN][3])
  82.       break;
  83.   }
  84. }
  85. void  exg_xyz(int *zyx_p, int *xyz_p)/*et*/
  86. {
  87.   int   i;
  88.   
  89.   for (i = 3; i; i--) {
  90.     *zyx_p = *xyz_p;
  91.     xyz_p += 2;
  92.     zyx_p += 2;
  93.   }
  94. }
  95. int   cmp_xyz(char *xyz_p, int k)/*et*/
  96. {
  97.   int   i, j;
  98.   char  *buf_p, *c_p;
  99.   
  100.   for (i = 1, j = 0; j < k && i; j++) {
  101.     c_p = xyz_p;
  102.     buf_p = (char*)((int)G_bf.et_buf + j * sizeof(ET));
  103.     for (i = sizeof(ET); i; i--)
  104.       if (*c_p++ != *buf_p++)
  105.         break;
  106.   }
  107.   if (!i)
  108.     if (test_bit(G_f, f_NN)) {
  109.       j--;
  110.       buf_p = G_bf.et_buf + (int)j * sizeof(ET);
  111.       _copy_buf(buf_p, (void*)((int)buf_p + sizeof(ET)), (k-j-1)*sizeof(ET));
  112.     }
  113.   return(i);
  114. }
  115. int   make_pna(char *pna_p)/*et*/
  116. {
  117.   FILE  *File, *Temp;
  118.   int   edge_i, mv;
  119.   char  *s_p, *val_p, s_a[1000], val_a[10];
  120.   ET    Et[1];
  121.   int   i, j, k, h, u, f, cut, cut_b, key_i;
  122.   int   *buf_p;
  123.   
  124.   res_bit(G_f, f_RR);
  125.   set_file_i(&P_c[c_FILE_BAK][8], 3);
  126.   if (test_bit(G_f, f_REPLAY)) {
  127.     cut_b = read_replay(0);
  128.     key_i = read_replay(0);
  129.   }
  130.   Temp = et_fopen(P_c[c_FILE_BAK], "wb", NULL);
  131.   G_nb.drive = *P_c[c_FILE_BAK];
  132.   File = et_fopen(pna_p, "rb", Temp);
  133.   edge_i = 0;
  134.   et_fwrite(&edge_i, sizeof(int), 1, Temp);
  135.   f = 0;
  136.   u = 0;
  137.   G_nb.edge = 0;
  138.   while (fgets(s_a, 999, File)) {
  139.     if (!test_bit(G_f, f_REPLAY))
  140.       MOS_rdpos(&u, &i, &i);
  141.     else 
  142.       if (key_i == edge_i)
  143.         u = cut_b;
  144.       else 
  145.         inkey(SCAN);
  146.     if (u)
  147.       break;
  148.     if (*s_a == 'p') {
  149.       if (!f) {
  150.         j = 0;
  151.         f = 1;
  152.         buf_p = (int*)G_bf.et_buf;
  153.       }
  154.       s_p = &s_a[11];
  155.       for (i = 3; i; i--) {
  156.         val_p = val_a;
  157.         while (*s_p != ' ' && *s_p != '.' && *s_p != 0x0d)
  158.           *val_p++ = *s_p++;
  159.         *val_p = '\0';
  160.         mv = atoi(val_a)*GETA_ET;
  161.         if (i == 2)
  162.           mv = -mv;
  163.         *buf_p++ = mv;
  164.         while (*s_p++ != ' ' && *s_p != 0x0d)
  165.           ;
  166.       }
  167.       j++;
  168.     } else {
  169.       if (!f)
  170.         continue;
  171.       f = 0;
  172.       buf_p = (int*)G_bf.et_buf;
  173.       G_nb.edge = 1;
  174.       for (i = k = 0; i < j-1; i++, k += 3) {
  175.         Et->xyz[0] = buf_p[k];
  176.         Et->xyz[1] = buf_p[k+3];
  177.         Et->xyz[2] = buf_p[k+1];
  178.         Et->xyz[3] = buf_p[k+4];
  179.         Et->xyz[4] = buf_p[k+2];
  180.         Et->xyz[5] = buf_p[k+5];
  181.         et_fwrite(Et, sizeof(ET), 1, Temp);
  182.         for (h = 2; h; h--, exchange_page())
  183.           if (test_bit(G_f, f_SV|f_GPH)) {
  184.             cul_edge(Et, G_edge, 1, _LT, h);
  185.             cul_edge(Et, G_bf.edge, 1, _RT, h);
  186.           } else
  187.             cul_edge(Et, G_edge, 1, 0, h);
  188.         edge_i++;
  189.       }
  190.       Et->xyz[0] = buf_p[k];
  191.       Et->xyz[1] = buf_p[0];
  192.       Et->xyz[2] = buf_p[k+1];
  193.       Et->xyz[3] = buf_p[1];
  194.       Et->xyz[4] = buf_p[k+2];
  195.       Et->xyz[5] = buf_p[2];
  196.       et_fwrite(Et, sizeof(ET), 1, Temp);
  197.       for (h = 2; h; h--, exchange_page())
  198.         if (test_bit(G_f, f_SV|f_GPH)) {
  199.           cul_edge(Et, G_edge, 1, _LT, h);
  200.           cul_edge(Et, G_bf.edge, 1, _RT, h);
  201.         } else
  202.           cul_edge(Et, G_edge, 1, 0, h);
  203.       edge_i++;
  204.     }
  205.   }
  206.   if (u != 2) {
  207.     fseek(Temp, 0L, 0);
  208.     et_fwrite(&edge_i, sizeof(int), 1, Temp);
  209.   }
  210.   fclose(File);
  211.   fclose(Temp);
  212.   switch(u) {
  213.   case 0:
  214.     cut = 0;
  215.     break;
  216.   case 1:
  217.     cut = _RET;
  218.     break;
  219.   case 2:
  220.     cut = _ESC;
  221.     break;
  222.   }
  223.   draw_cut(cut);
  224.   if (u) {
  225.     if (!test_bit(G_f, f_REPLAY)) {
  226.       write_replay(u);
  227.       write_replay(edge_i);
  228.     }
  229.     if (u == 2)
  230.       unlink(P_c[c_FILE_BAK]);
  231.     else
  232.       u = 0;
  233.   } else 
  234.     if (!test_bit(G_f, f_REPLAY)) {
  235.       write_replay(0);
  236.       write_replay(-1);
  237.     }
  238.   return((u) ? _ESC : _RET);
  239. }
  240. void  clip_pq(int pq_a[], unsigned *f1_p, unsigned *f2_p, int xv_l, int xv_r, int i)/*et*/
  241. {
  242.   unsigned  *f_p;
  243.   int   p_d, q_d;
  244.   int   *p1_p, *q1_p, *p2_p, *q2_p;
  245.   
  246.     f_p = (i) ? f2_p : f1_p;
  247.     p1_p = &pq_a[i*2];
  248.     q1_p = p1_p+1;
  249.     p2_p = &pq_a[!i*2];
  250.     q2_p = p2_p+1;
  251.     p_d = *p2_p - *p1_p;
  252.     q_d = *q2_p - *q1_p;
  253.     if (*f_p & 1) {
  254.       *f_p &= ~1;
  255.       *q1_p = q_d * (xv_l - *p1_p) / p_d + *q1_p;
  256.       *p1_p = xv_l;
  257.     } else if (*f_p & 2) {
  258.       *f_p &= ~2;
  259.       *q1_p = q_d*(xv_r-1 - *p1_p) / p_d + *q1_p;
  260.       *p1_p = xv_r - 1;
  261.     }
  262.     if (*f_p & 4) {
  263.       *f_p &= ~4;
  264.       *p1_p = p_d * (-G_vi.y - *q1_p) / q_d + *p1_p;
  265.       *q1_p = -G_vi.y;
  266.     } else if (*f_p & 8) {
  267.       *f_p &= ~8;
  268.       *p1_p = p_d * (G_vi.y-1 - *q1_p) / q_d + *p1_p;
  269.       *q1_p = G_vi.y - 1;
  270.     }
  271.     if (*p1_p < xv_l)
  272.       *f_p |= 1;
  273.     else if (*p1_p >= xv_r)
  274.       *f_p |= 2;
  275.     if (*q1_p < -G_vi.y)
  276.       *f_p |= 4;
  277.     else if (*q1_p >= G_vi.y)
  278.       *f_p |= 8;
  279. }
  280. int   move_et(int n, int key_i)/*et*/
  281. {
  282.   int   i, j, k;
  283.   
  284.   j = G_pm.i.angle;
  285.   k = 0;
  286.   switch(n) {
  287.   case 1:
  288.     G_ps.x += (int)G_pm.i.x_step * GETA_ET;
  289.     break;
  290.   case 2:
  291.     G_ps.x -= (int)G_pm.i.x_step * GETA_ET;
  292.     break;
  293.   case 3:
  294.     G_ps.y += (int)G_pm.i.y_step * GETA_ET;
  295.     break;
  296.   case 4:
  297.     G_ps.y -= (int)G_pm.i.y_step * GETA_ET;
  298.     break;
  299.   case 5:
  300.     G_ps.z += (int)G_pm.i.z_step * GETA_ET;
  301.     break;
  302.   case 6:
  303.     G_ps.z -= (int)G_pm.i.z_step * GETA_ET;
  304.     break;
  305.   case 7:
  306.     j = 90;
  307.   case 13:
  308.     G_ps.x_g += j;
  309.     x_rot((int)icos(j), -(int)isin(j));
  310.     break;
  311.   case 8:
  312.     j = 90;
  313.   case 14:
  314.     G_ps.x_g -= j;
  315.     x_rot((int)icos(j), (int)isin(j));
  316.     break;
  317.   case 9:
  318.     j = 90;
  319.   case 15:
  320.     G_ps.y_g += j;
  321.     y_rot((int)icos(j), -(int)isin(j));
  322.     break;
  323.   case 10:
  324.     j = 90;
  325.   case 16:
  326.     G_ps.y_g -= j;
  327.     y_rot((int)icos(j), (int)isin(j));
  328.     break;
  329.   case 11:
  330.     j = 90;
  331.   case 17:
  332.     G_ps.z_g -= j;
  333.     z_rot((int)icos(j), (int)isin(j));
  334.     break;
  335.   case 12:
  336.     j = 90;
  337.   case 18:
  338.     G_ps.z_g += j;
  339.     z_rot((int)icos(j), -(int)isin(j));
  340.     break;
  341.   case 19:
  342.   case 20:
  343.     if (test_bit(G_f, f_TROFF)) {
  344.       res_bit(G_f, f_TROFF);
  345.       if (test_bit(G_f, f_FF))
  346.         set_bit(G_f, f_TRON);
  347.     } else {
  348.       set_bit(G_f, f_TROFF);
  349.       if (test_bit(G_f, f_FF))
  350.         res_bit(G_f, f_TRON);
  351.     }
  352.     k = _TAB;
  353.     break;
  354.   case 21:
  355.   case 22:
  356.     if (test_bit(G_f, f_REV))
  357.       res_bit(G_f, f_REV);
  358.     else
  359.       set_bit(G_f, f_REV);
  360.     if (!test_bit(G_f, f_BLIND)) {
  361.       draw_edge(P_SET, AFT);
  362.       for (i = 2; i; i--, exchange_page())
  363.         mark_rev();
  364.       draw_edge(P_RES, AFT);
  365.     }
  366.     k = _INS;
  367.     break;
  368.   case 23:
  369.   case 24:
  370.     G_nb.edge_b = G_nb.edge;
  371.     do {
  372.       G_pn.csr++;
  373.     } while (EOC != *G_pn.csr && *G_pn.csr == G_nb.et);
  374.     if (EOC != *G_pn.csr) {
  375.       G_nb.et = *G_pn.csr;
  376.       load_et(G_nb.et, 1);
  377.       if (test_bit(G_f, f_SV|f_GPH)) {
  378.         if (!test_bit(G_f, f_EE)) {
  379.           copy_edge(STORE, BEF);
  380.           cul_edge(G_et, G_edge, G_nb.edge, _LT, 0);
  381.           cul_edge(G_et, G_bf.edge, G_nb.edge, _RT, 0);
  382.           if (!test_bit(G_f, f_BLIND)) {
  383.             exchange_page();
  384.             copy_edge(RESTORE, BEF);
  385.             draw_edge(P_RES, BEF);
  386.             set_bit(G_f, f_BLIND);
  387.             cul_edge(G_et, G_edge, G_nb.edge, _LT, 0);
  388.             cul_edge(G_et, G_bf.edge, G_nb.edge, _RT, 0);
  389.             res_bit(G_f, f_BLIND);
  390.           }
  391.         }
  392.       } else {
  393.         _copy_buf(G_bf.edge, G_edge, sizeof(EDGE)*G_nb.edge_b);
  394.         if (!test_bit(G_f, f_EE)) {
  395.           cul_edge(G_et, G_edge, G_nb.edge, 0, 0);
  396.           if (!test_bit(G_f, f_BLIND)) {
  397.             exchange_page();
  398.             draw_edge(P_RES, BEF);
  399.           }
  400.         }
  401.       }
  402.       G_nb.edge_b = G_nb.edge;
  403.     }
  404.     k = S_RET;
  405.     break;
  406.   default:
  407.     break;
  408.   }
  409.   G_mv[key_i++].key = n;
  410.   if (!test_bit(G_f, f_SPLINE)) {
  411.     G_mv[key_i].x = G_ps.x;
  412.     G_mv[key_i].y = G_ps.y;
  413.     G_mv[key_i].z = G_ps.z;
  414.   }
  415.   if (!test_bit(G_f, f_RR))
  416.     G_mv[key_i].r = G_pm.i.r;
  417.   G_nb.key_i = key_i;
  418.   return(k);
  419. }
  420. void  set_flag(unsigned *f1_p, unsigned *f2_p, int pq_a[], int xv_l, int xv_r)/*et*/
  421. {
  422.   
  423.   *f1_p = 0;
  424.   if (pq_a[0] < xv_l)
  425.     *f1_p |= 1;
  426.   else if (pq_a[0] >= xv_r)
  427.     *f1_p |= 2;
  428.   if (pq_a[1] < -G_vi.y)
  429.     *f1_p |= 4;
  430.   else if (pq_a[1] >= G_vi.y)
  431.     *f1_p |= 8;
  432.   *f2_p = 0;
  433.   if (pq_a[2] < xv_l)
  434.     *f2_p |= 1; 
  435.   else if (pq_a[2] >= xv_r)
  436.     *f2_p |= 2;
  437.   if (pq_a[3] < -G_vi.y)
  438.     *f2_p |= 4;
  439.   else if (pq_a[3] >= G_vi.y)
  440.     *f2_p |= 8;
  441. }
  442.